// SimpleNote Service Worker
const CACHE_NAME = 'simplenote-v1.0.0';
const STATIC_CACHE = 'simplenote-static-v1.0.0';
const DYNAMIC_CACHE = 'simplenote-dynamic-v1.0.0';

// 需要缓存的静态资源
const STATIC_ASSETS = [
  '/',
  '/index.html',
  '/style.css',
  '/app.js',
  '/manifest.json',
  '/icons/github.svg',
  '/icons/gitee.svg'
];

// 需要缓存的动态资源
const DYNAMIC_ASSETS = [
  // 不再预缓存API端点，避免不必要的请求
];

// 安装事件
self.addEventListener('install', (event) => {
  console.log('Service Worker 安装中...');
  
  event.waitUntil(
    Promise.all([
      // 缓存静态资源
      caches.open(STATIC_CACHE).then((cache) => {
        console.log('缓存静态资源...');
        return cache.addAll(STATIC_ASSETS).catch((error) => {
          console.warn('部分静态资源缓存失败:', error);
          // 尝试逐个添加资源
          return Promise.allSettled(
            STATIC_ASSETS.map(url => 
              cache.add(url).catch(err => {
                console.warn(`缓存 ${url} 失败:`, err);
                return null;
              })
            )
          );
        });
      }),
      // 预缓存动态资源
      caches.open(DYNAMIC_CACHE).then((cache) => {
        console.log('预缓存动态资源...');
        return cache.addAll(DYNAMIC_ASSETS).catch((error) => {
          console.warn('部分动态资源缓存失败:', error);
          return Promise.resolve();
        });
      })
    ]).then(() => {
      console.log('Service Worker 安装完成');
      // 立即激活新的 Service Worker
      return self.skipWaiting();
    }).catch((error) => {
      console.error('Service Worker 安装失败:', error);
    })
  );
});

// 激活事件
self.addEventListener('activate', (event) => {
  console.log('Service Worker 激活中...');
  
  event.waitUntil(
    Promise.all([
      // 清理旧缓存
      caches.keys().then((cacheNames) => {
        return Promise.all(
          cacheNames.map((cacheName) => {
            if (cacheName !== STATIC_CACHE && cacheName !== DYNAMIC_CACHE) {
              console.log('删除旧缓存:', cacheName);
              return caches.delete(cacheName);
            }
          })
        );
      }),
      // 立即控制所有客户端
      self.clients.claim()
    ]).then(() => {
      console.log('Service Worker 激活完成');
    })
  );
});

// 拦截网络请求
self.addEventListener('fetch', (event) => {
  const { request } = event;
  const url = new URL(request.url);
  
  // 只处理 GET 请求
  if (request.method !== 'GET') {
    return;
  }
  
  // 处理静态资源
  if (STATIC_ASSETS.includes(url.pathname)) {
    event.respondWith(
      caches.match(request).then((response) => {
        if (response) {
          return response;
        }
        return fetch(request).then((fetchResponse) => {
          const responseClone = fetchResponse.clone();
          caches.open(STATIC_CACHE).then((cache) => {
            cache.put(request, responseClone);
          });
          return fetchResponse;
        });
      })
    );
    return;
  }
  
  // 处理 Git API 请求 - 总是获取最新数据，不缓存API响应
  if (url.hostname === 'gitee.com') {
    event.respondWith(
      fetch(request).then((fetchResponse) => {
        return fetchResponse;
      }).catch(() => {
        // 网络失败时返回离线页面
        return new Response(
          JSON.stringify({
            error: '网络连接失败',
            message: '请检查网络连接后重试'
          }),
          {
            status: 503,
            statusText: 'Service Unavailable',
            headers: { 'Content-Type': 'application/json' }
          }
        );
      })
    );
    return;
  }
  
  // 处理其他请求
  event.respondWith(
    fetch(request).catch(() => {
      // 网络失败时返回离线提示
      if (request.destination === 'document') {
        return caches.match('/index.html');
      }
      return new Response('离线模式', {
        status: 503,
        statusText: 'Service Unavailable'
      });
    })
  );
});

// 处理推送通知
self.addEventListener('push', (event) => {
  console.log('收到推送通知:', event);
  
  const options = {
    body: event.data ? event.data.text() : 'SimpleNote 通知',
    icon: '/icons/icon-192.png',
    badge: '/icons/icon-192.png',
    vibrate: [100, 50, 100],
    data: {
      dateOfArrival: Date.now(),
      primaryKey: 1
    },
    actions: [
      {
        action: 'explore',
        title: '查看详情',
        icon: '/icons/icon-192.png'
      },
      {
        action: 'close',
        title: '关闭',
        icon: '/icons/icon-192.png'
      }
    ]
  };
  
  event.waitUntil(
    self.registration.showNotification('SimpleNote', options)
  );
});

// 处理通知点击
self.addEventListener('notificationclick', (event) => {
  console.log('通知被点击:', event);
  
  event.notification.close();
  
  if (event.action === 'explore') {
    // 打开应用
    event.waitUntil(
      clients.openWindow('/')
    );
  } else if (event.action === 'close') {
    // 关闭通知
    event.notification.close();
  } else {
    // 默认行为：打开应用
    event.waitUntil(
      clients.openWindow('/')
    );
  }
});

// 处理后台同步
self.addEventListener('sync', (event) => {
  console.log('后台同步:', event.tag);
  
  if (event.tag === 'background-sync') {
    event.waitUntil(
      // 执行后台同步逻辑
      doBackgroundSync()
    );
  }
});

// 后台同步函数
async function doBackgroundSync() {
  try {
    // 获取所有客户端
    const clients = await self.clients.matchAll();
    
    // 通知所有客户端执行同步
    clients.forEach((client) => {
      client.postMessage({
        type: 'BACKGROUND_SYNC',
        message: '执行后台同步'
      });
    });
    
    console.log('后台同步完成');
  } catch (error) {
    console.error('后台同步失败:', error);
  }
}

// 处理消息
self.addEventListener('message', (event) => {
  console.log('收到消息:', event.data);
  
  if (event.data && event.data.type === 'SKIP_WAITING') {
    self.skipWaiting();
  }
  
  if (event.data && event.data.type === 'GET_VERSION') {
    event.ports[0].postMessage({
      version: CACHE_NAME
    });
  }
});

// 错误处理
self.addEventListener('error', (event) => {
  console.error('Service Worker 错误:', event.error);
});

self.addEventListener('unhandledrejection', (event) => {
  console.error('Service Worker 未处理的 Promise 拒绝:', event.reason);
});

// 定期清理缓存
setInterval(() => {
  caches.keys().then((cacheNames) => {
    cacheNames.forEach((cacheName) => {
      if (cacheName !== STATIC_CACHE && cacheName !== DYNAMIC_CACHE) {
        caches.delete(cacheName);
      }
    });
  });
}, 24 * 60 * 60 * 1000); // 每24小时清理一次
